3. Ejercicios de programación
Haga un programa que nos
pregunte el nombre y luego nos salude por nuestro nombre y nos
pregunte como estamos. Que de dos respuestas, dependiendo de si
la respuesta del usuario es "bien" o "mal", y otra respuesta si
da una respuesta diferente.
Desarrolle un programa user-rpl que Borre TODO lo que hay
en la calculadora. ****
Haga un programa que invierta el orden de las variables del
directorio actual
Haga un programa que llene la calculadora con basura dificil de
quitar de manera que al usuario se le agote la
memoria.****
Haga un programa que Infecte todos los demas programas del
directorio actual con un código escondido que al final del
programa se pegue y que al ejecutar los programas infectados no
se ejecute el código que se pegó.(vírico
suave).*****
Desarrolle un software que dada una lista
de números cualquiera en la pila, nos entregue otra lista
con los números ordenados de mayor a menor
Bien, ahora larguemonos a ver los códigos de los
programas que les mandé hacer, y si ustedes ni siquiera se
dieron el trabajo de
tratar de hacer los ejercicios entonces vayanse a la misma
mierda, pues no aprenderan nada. Ahhhh, y se me ólvidaba,
para todos aquellos que quieren impresionar a sus amigos con el
código del virus que
daré vayanse a ver tata colores y a
hecharse una pajita, ya que no daré aquí los
códigos de los programas marcados al final con
*****, y si tu eres un real programador, demuestramelo en
simples palabras y explicame que no te la pudiste con alguno de
los trabajos y escribe a milun[arroba]starmedia.com y te mando al
tiro los códigos. Recuerda siempre ignorar y aborrecer a
toda esa manga de pendejos que anda por ahi dándoselas de
hacker
maligno.
Ejercicio 1 :
<< "Hola " "¿Cual es su nombre?" "" INPUT + ",
como está?" + "" INPUT -> VYS << CASE VYS BIEN
== THEN
"QUE BUENO" MSGBOX END VYS MAL == THEN "QUE PENA" MSGBOX
END "RESPONDE BIEN O MAL, JETON" MSGBOX OFF >>
>>
Ejercicio 3 :
<< VARS REVLIST ORDER >>
Que fácil no ?, al menos aprendiste el comando REVLIST
y ORDER. Si los conocias desde antes, mejor, vas por el buen
camino.
Ejercicio 6 :
<< SORT REVLIST >>
No digas nada y date cuenta de el funcionamiento del SORT
¿Que pasaría si ahora escribimos un programa en
serio?. A ver, despues de pensar un rato recordé un
programa que hice el año pasado. era para trabajo con
triángulos. Me imagino que la mayoría de los
posibles lectores de este manual
estará de alguna manera relacionado con los
triángulos, o al menos estudiando matematicas. Entonce
haremos un programa que conste de varias partes, Una primera
parte que dados los tres lados del triángulo nos dé
el valor del area
de triángulo(Herón). Una segunda parte que dados
los tres lados del triángulo nos diga si es
acutángulo, rectángulo o obtusángulo. Otra
tercera parte que dados los tres lados del triángulo nos
entregue el valor de sus ángulos interiores en grados
sexagesimales. Una cuarta parte que dados los tres lados nos
dé el valor de sus trés alturas. Una quinta parte
que nos dé el valor de sus tres transversales de gravedad
y una sexta parte que nos dé el valor de sus tres
bisectrices.
Bien, desde aquí se ve duro el trabajo, pero les doy un
buen consejo, hagan el trabajo ustedes. NO se limiten a estudiar
solo el código. Traten y se sentiran mucho mejor, no hagan
nada y serán siempre una mierda asquerosa y sarnosa que se
podrirá en el inodoro infectado de porqueria humana.
Si conocen los triángulos, se darán cuenta de
que me faltaron las SIMETRALES. Esto devido a que el trabajo para
encontrar las simetrales dados los tres lados es un poco mas
complicado. Y las medianas no las puse por que simplemente es muy
facil calcularlas.
Bueno, quisiera dejar en claro que yo no me las llevo "pelas"
ya que este programa lo perdí hace mucho tiempo en un
"memory clear" que me ocurrió hace varios varios meses,
así que tendré que trabajar duro yo también
para hacer nacer el código desde lo profundo de mi alma de
programador. juijuijui.
En la escritura del
código , pondré al principio de cada parte del
código de una parte del programa el nombre de esa
parte.
(debido a problemas del
texto, el
digno de la raiz cuadrada lo escribire de la forma (4)^0.5, o
sea, cuatro elevado a 0.5
@******************************************************************@
@——————–Programa
ESTRIANGULADOR———————–@
@————————by
xj35u5x——————————–@
@******************************************************************@
@ Módulo : HERON
@ Código :
<< -> A B C << A B C + + 2 / -> S
'(S*(S-A)*(S-B)*(S-C))^0.5' >> >>
@ Módulo : ARO
@ Código :
<< -> A B C << A 2 ^ B 2 ^ C 2 ^ -> a b c
<< a b c + < b a c + <
c a b + < OR IF OR THEN "ACUTANGULO" MSGBOX ELSE a b c +
==
b c a + == c a b + == OR IF OR THEN "RECTANGULO" MSGBOX
ELSE
a b c + > c a b + > b a c + > OR IF OR THEN
"OBTUSANGULO"
MSGBOX END END END >> >> >>
@ Módulo : ANGULOS
@ Código :
<< DEG
-> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C * * / ACOS A
2 ->LIST
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS B 2 ->LIST
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS C 2 ->LIST
>> >>
@ Módulo : ALTURAS
@ Código :
<< -> A B C << A B C HERON -> AREA <<
AREA 2 * A / A 2 ->LIST
AREA 2 * B / B 2 ->LIST
AREA 2 * C / C 2 ->LIST
>> >> >>
@ Módulo : TRANSVERSAL
@ Código :
<< -> A B C << A 2 / B 2 / C 2 /
B 2 ^ C 2 ^ + A 2 ^ – 2 B C * * / ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS
-> a b c ALFA BETA GAMMA <<
C 2 ^ a 2 ^ + C a * 2 * BETA COS * – 0.5 ^ A 2 ->LIST
A 2 ^ b 2 ^ + A b * 2 * GAMMA COS * – 0.5 ^ B 2 ->LIST
B 2 ^ c 2 ^ + B c * 2 * ALFA COS * – 0.5 ^ C 2 ->LIST
>> >> >>
@ Módulo : BISECTRIZ
@ Código :
<< DEG -> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C
* * / ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS
-> alfa beta gamma <<
C beta SEN * 180 beta – alfa 2 / – SEN / A 2 ->LIST
A gamma SEN * 180 gamma – beta 2 / – SEN / B 2 ->LIST
B alfa SEN * 180 alfa – gamma 2 / – SEN / C 2 ->LIST
>> >> >>
@******************************************************************@
@ Programado por Sebastian Rivas milun[arroba]starmedia.com
@
@ Concepcion-Chile
año 2000 copyleft @
@******************************************************************@
Y ahí por fín está nuestra SUITE de
triángulos. Si fuiste un buen niño y trabajaste
duro para sacar adelante tu código propio mil
felicitaciones, entonces si tienes partes mejores o más
optimizadas que las mías hazmelo saber, estas en todo tu
derecho, o planteame tus diferencias o detalles, o lo que sea.
Felicitaciones para quien logró o trató al menos de
desarrollar el programa. Y como dato ilustrativo quisiera decir
que el programa en sí tiene algo que se le puede
optimizar, lo cual lo puse a propósito.
Bien, ahora un descanzo por un tiempo. adios.
4. "El programa dueño y una
pincelada a la programacion de juegos o
aplicaciones interactivas mediante el uso de la inmersion y las
estrucuras xj35u5x. un poco de cadenas "
El nombre de este capítulo se debe a que veremos otro
código pero este yo creo que es más fácil
que el del programa "estriangulador". Lo que hace el programa es
que en el encendido de la calculadora aparezca el nombre del
dueño de la calculadora por 1 segundo, claro que para esto
la calculadora se debe apagar ejecutando al programa. En el resto
del capítulo iremos mirando otras cosas muy
interesantes.
Por primera vez veremos una técnica que por ahora
llamaremos
Instalacion previa, la cual consiste en que los programas se
instalan y crean ellos mismos otros archivos
ejecutables para luego auto-aniquilarse y dejar el programa
"hijo" residente en memoria.
<< << PICT RCL ERASE OFF NOMBRExx { 1 { #5h #18h }
1 1 } IFERR ANIMATE THEN { DUEÑO } PURGE END DROP DROP
PICT
STO >> DUEÑO IFERR STO THEN
"EL PROGRAMA YA ESTA INSTALADO Y SU NOMBRE ES DUEÑO"
MSGBOX
ELSE "DIGAME SU NOMBRE" "" INPUT 3 ->GROB NOMBRExx STO
"EL PROGRAMA HA SIDO INSTALADO CON EXITO" MSGBOX
END >>
Bueno, para que analizar una cosa tan simple.
Quisiera hacer un disclaimer, por favor, cualquier error que
se encuentre en mis códigos háganmelo saber y os
daré las gracias, ya que yo igual soy humano y me puedo
equivocar a pesar de que casi siempre los pruebo en mi propia
humilde hp48g . Si, yo poseo una hp48g y no una hp48gx,
aunque ya me esta quedando muy chica esta
……….y no es chiste…… >8^)
<< "PERDISTE" MSGBOX >>
Ese código es de un juego muy muy
dificil. Ejecutadlo….
Bueno, pongámonos serios otra vez. A ver, de que
podríamos hablar…mmmm….hablemos un rato de la programación de juegos en la hp48.
La primera vez que me aventuré a hacer un juego
gráfico fue el año 99 , cuando llevaba como 7 meses
usando mi hp en el cuarto medio o el último año de
preparatoria. Recuerdo que comencé planteandome el
desafío de hacer un programa que imitara a una pelota que
rebotara por toda la pantalla de la hp48. La pelota sería
un simple punto, y despues de muchos fallos y derrotas, lo
logré. Era un poco lenta, claro, debido a que yo
aún ni me sabía la mitad de los comandos de la hp
y en ocasiones por no saber un comando, lo imitaba con 4 o 5
instrucciones conocidas por mi, y debido también a la
natural lentitud del lenguaje
user-rpl. Bueno, entonces, cuando la pelota estaba lista y
funcionaba, se me ocurrió que podría ser un juego
si lograba poner en uno de los lados de la pantalla una barra que
actuara como paleta(parecido a los antiguos juegos de
atarí mientras cargaban), que se moviera dependiendo de
las teclas que yo apretara. Entonces conocí el gran
comando WAIT y comencé la mounstrosa tarea. Es que para
mi, que apenas sabía un poco, era muy dificil llegar a
eso. Pero al final lo logré. Pero entonces no estube
contento con una sola paleta, y se me ocurrio que se
podría hacer con 2 jugadores, onda tenis o ping pong. Y
también eso lo logré. El programa era ridiculamente
lento, pero fué lo que me animó a meterme en la
programacion user-rpl. Bien, ahora, yo se que quizá eso a
ustedes no les interesa en lo más mínimo, pero
deben extraer del texto la palabra WAIT, por que aunque sé
que he mejorado como programador, es la misma idea que se me
ocurrio aquella vez la que sigo usando para mis juegos. Es la
estructura que
yo uso y que por no tener nombre oficial llamaré
"Estructura xj35u5x" (disculpen por poner mi nick ahí,
pero……¡¡soy humano!! me gusta eso….. ;->
Estructura : xj35u5x
Lo que hace esta estructura es usar de manera conveniente los
comandos WAIT ,ANIMATE y PVIEW la estructura CASE THEN END END
para manejar los gráficos de la hp de forma que nosotros
queramos, con respuestas a las teclas que se pulsan y el tiempo,
etc. En realidad, todo lo que se nos ocurra.
Como primer ejemplo veremos un programa que lo único
que hace es mover un punto hacia donde nosotros queramos, con las
teclas de direccion.
Codigo ejemplo
1 :
<< {PUNTOX} PURGE (0,0)
<< DUP PIXON {#0 #0} PVIEW 0 WAIT -> A <<
CASE
'A==36.1' THEN DUP PIXOFF (.5,0) + PUNTOX END
'A==34.1' THEN DUP PIXOFF (-.5,0) + PUNTOX END
'A==25.1' THEN DUP PIXOFF (0,.5) + PUNTOX END
'A==35.1' THEN DUP PIXOFF (0,-.5) + PUNTOX END
"VIVA EL ENRIQUE MOLINA" MSGBOX {PUNTOX} PURGE END
>>
PUNTOX STO PUNTOX >>
Se acuerdan de la palabra optimizacion ???
Codigo mejorado ejemplo 1 :
<< {PUNTOX} PURGE (0,0)
<< DUP PIXON {#0 #0} PVIEW 0 WAIT -> A <<
CASE
'A==36.1' THEN DUP PIXOFF (.5,0)
'A==34.1' THEN DUP PIXOFF (-.5,0)
'A==25.1' THEN DUP PIXOFF (0,.5)
'A==35.1' THEN DUP PIXOFF (0,-.5)
"VIVA EL ENRIQUE MOLINA" MSGBOX {PUNTOX}
PURGE END IFERR + PUNTOX THEN END END
>> PUNTOX STO PUNTOX >>
Así nos ahorramos unos cuantos bytes
y ahora :
<< {PUNTOX Xx} PURGE << DUP PIXOFF >> Xx STO
(0,0)
<< DUP PIXON {#0 #0} PVIEW 0 WAIT -> A <<
CASE
'A==36.1' THEN Xx (.5,0)
'A==34.1' THEN Xx (-.5,0)
'A==25.1' THEN Xx (0,.5)
'A==35.1' THEN Xx (0,-.5)
"VIVA EL ENRIQUE MOLINA" MSGBOX {PUNTOX Xx}
PURGE END IFERR + PUNTOX THEN END END
>> PUNTOX STO PUNTOX >>
Mejor.
Bien, ademas de ilustrar el uso de una estrucura xj35u5x, el
ejemplo sirvió también para ejemplarizar el uso de
otra tecnica, la que
consiste en que los programas creen otros programas en tiempo
real y los ejecuten. por que si te das cuenta, el ejemplo
haría lo mismo que este código :
<< DUP PIXON {#0 #0} PVIEW 0 WAIT -> A <<
CASE
'A==36.1' THEN Xx (.5,0)
'A==34.1' THEN Xx (-.5,0)
'A==25.1' THEN Xx (0,.5)
'A==35.1' THEN Xx (0,-.5)
"VIVA EL ENRIQUE MOLINA" MSGBOX {PUNTOX Xx}
PURGE END IFERR + PUNTOX THEN END END
>>
Siempre y cuando se guardara con el nombre PUNTOX y al momento
de ejecucion hubiera un par ordenado en el nivel 1: de la
pila.
Pero como siempre hay gente muy muy, bueno, el típico
usuario, más vale de la primera forma. Por ejemplo si
haces un programa que tiene varias partes y quieres distribuirlo
pensaras que a cada weon que quiera usarlo tendras que pasarle
como 8 archivos. Entonces es MUY util esta técnica a la
que por ahora llamaremos INMERSION.
En sintesis, la
tecnica de inmersion es transformar un programa que contiene
varios archivos a uno que tenga uno solo, y que cuando sea
ejecutado creará a los demas archivos y ejecutará
el principal.(se hechan de menos las funciones de C ).
Luego de la ejecución, todos los archivos auxiliares son
destruidos nuevamente.
Disculpen por salirme del tema, pero es que en algún
momento tenía que decirles lo de la INMERSION. Ahora,
siguiendo con las estructuras
xj35u5x, veremos algo en donde usemos ANIMATE.
Hagamos un programa que desplace por la pantalla a nuestro
antojo un objeto de gráficos que de antemano dibujaremos y
guardaremos como variable con un nombre determinado que en ESTE
caso será A1. Podría ser un círculo,un
cuadrádo, o….si!!!, también podría ser una
nave espacial intergaláctica.
Bien, ahora, sabiendo que existe la variable A1 que contiene
un gráfico el código sería :
Antes de dar el código quisiera explicar una vez
más que el uso de este manual sin el manual de usuario, o
sin ningún conocimiento
del lenguaje o los comandos será de escasa o nula ayuda en
tu carrera de programador, si estas solo copiando los
códigos a la hp y jugando, está muy bien si no te
interesa la programación, pero si quieres hacer lo que yo
hago, y mejor, entonces estarías puro cagándola,
por que ademas, cada uno tiene que tener su propio estilo.
<< << { 1 { #0d #0d } 0 1 } PICT RCL { #0d #0d }
TO111 >> TOCERO STO << -> W << X1 GOR SWAP
ANIMATE 0 WAIT -> Z <<
CASE 'Z==36.1' THEN W DUP PX->C (.5,0) + C->PX TO222
END
'X==35.1' THEN W DUP PX->C (0,-.5) + C->PX TO222 END
'X==25.1' THEN W DUP PX->C (0,.5) + C->PX TO222 END
'X==34.1' THEN W DUP PX->C (-.5,0) + C->PX TO222 END
"PROGRAMADO POR xj35u5x" MSGBOX { TOCERO TO111 TO222 }
PURGE END >> >> >> TO111 STO
<< -> A B << SWAP A PX->C X2 REPL B TO111
>> >> TO222 STO
{ TO111 } BYTES DROP IF #60853d == THEN TOCERO ELSE { TOCERO
TO111 TO222 } PURGE END >>
Ese es el código necesario sabiendo que en el
directorio actual hay una variable llamada X1 con un dibujo y otra
llamada X2 igual que grande que X1 pero vacia.
Y en caso de que sea un programa para pasarselo a tus
ignorantes amigos ???? ¿¿¿acaso ellos
dibujarán un gráfico y crearan un BLANK ???? no,
entonces el código sería…..
<< { X1 X2 TOCERO TO111 TO222 } PURGE << { 1 { #0d
#0d } 0 1 } PICT RCL { #0d #0d } TO111 >> TOCERO STO
<< -> W << X1 GOR SWAP ANIMATE 0 WAIT -> Z
<<
CASE 'Z==36.1' THEN W DUP PX->C (.5,0) + C->PX TO222
END
'X==35.1' THEN W DUP PX->C (0,-.5) + C->PX TO222 END
'X==25.1' THEN W DUP PX->C (0,.5) + C->PX TO222 END
'X==34.1' THEN W DUP PX->C (-.5,0) + C->PX TO222 END
"PROGRAMADO POR xj35u5x" MSGBOX
{ X1 X2 TOCERO TO111 TO222 } PURGE END >> >>
>> TO111 STO
<< -> A B << SWAP A PX->C X2 REPL B TO111
>> >> TO222 STO
GROB 8 8 C12214141422C100 X1 STO
GROB 8 8 0000000000000000 X2 STO
{ TO111 } BYTES DROP IF #60853d == THEN TOCERO ELSE { TOCERO
TO111 TO222 X1 X2 } PURGE END >>
Ten en cuenta que el programa lleva una pequeña
protección. Hazlo correr así como está y
luego en donde dice xj35u5x pon tu nombre y vé que pasa.
Estaríamos acercandonos poco a poco a un importante tema
para nosotros los programadores, que es proteger nuestros
programas de gente charcheta que le gusta darselas de programador
o de vacan simplemente, pero en realidad son lo más poser
de lo poser, lo más nerdie de lo nerdie.
Así es este manual, este es un manual de programacion o
mejor dicho de ideas de programación. Recuerdo que el
primer ejemplo de programación fué :
<< "HOLA MUNDO" MGSBOX >>
Hemos avanzado eh……
Bien, tengo varias ideas en la cabeza pero no se cual mostrar
primero…. a ver… dejemos de lado un rato las estructuras
xj35u5x para pasar a analizar algunos temas. En todo caso, yo no
creo que vuelva a hablar mucho de las e.xj35u5x , ya que con lo
que dije, solo falta más imaginación para crear
cosas más interesantes. En base a eso yo programé
un juego llamado gato, y aunque el juego en si es simple,
quedó muy bien hecho. Lo que quiero decir es que la
tecnica de usar las estructuras xj35u5x es muy poderosa, basta
con pensar en que a mi me ha bastado durante al menos un
año programando distintos tipos de cosas.
Vámonos ahora a hablar un ratito sobre algo que a
algunos puede desagradar un poco. Las matemáticas. Todos sabemos que el 99.99% de
los usuarios de hp48 estan en estudios que incluyen a las
matematicas de alguna forma, entonces, debido a este hecho es que
la programación de aplicaciones matemáticas se hace
imprescindible. Yo sé que muchos de lo usuarios que hay
allá afuera no usan la hp para otra cosa que no sea jugar,
pero, hay otro porcentaje que quiere hacer cosas más
productivas con ella. También hay que tomar en cuenta el
porcentaje de usuarios que la usan para su trabajo.
Mi nivel de matemáticas no es tan alto, ya que en el
momento que estoy escribiendo este manual voy en primer
año de ingeniería, por lo que mi cultura
matemática
no es muy alta, pero para los programadores más mate-magos
les dejo el desafío de crear aplicaciones que les sean
útiles.
La hp48 es un intrumento que fué creado para las
matemáticas, numéricas y simbólicas,
así que no es nada nada en vano programar aplicaciones
matemáticas. Daré algunos problemillas para la casa
🙂
Haga un programa que pase de radianes a grados.
Haga un programa que nos diga en cualquier momento cuanto
falta para el año 2001.
Haga un programa que nos dé el area de un
pentágono regular dado su lado.
Haga un programa que nos dé el volumen de una
esfera dado su radio(extremadamente fácil)
Haga un programa que nos dé la medida del lado de un
dodecágono regular, el cual está inscrito en una
circunferencia, dado el lado de un pentágono regular
circunscrito en la misma circunferencia.
(extremadamente difícil)
Haga un programa que dados dos números "a" y "b" en la
pila de la forma :
2: a
1: b
nos diga si a es divisible por b o no.
Bien, con esos ejercicios basta por ahora. (quien los haga y
quiera mi felicitación que me mande su código
fuente y yo lo probaré y le enviaré mis
felicitaciones personales….
Pero ahora es hora de un verdadero desafío. Escriba un
programa que simule una pelota que rebota infinitamente por la
pantalla, es decir que nunca para……a ver quien se la
puede……
Bien, realmente no se por donde seguir, yo creo que lo
mejor sería hablar un rato sobre las cadenas.
El manejo de las cadenas es algo muy importante en todo
lenguaje de
programación, ya que nos permite una fácil
comunicación con el usuario. Los programas
de inteligencia
artificial están la mayoría escritos en
lenguajes que tienen mucho poder sobre
las cadenas como por ejemplo el LISP. Y bueno, como algunos de
ustedes sabran, el SYSTEM-RPL es como un hijo del LISP, y
el lenguaje
que ustedes están aprendiendo en este momento es un hijo
del SYSTEM-RPL. a ver quien saca la conclusion…….
:-))))))))
Ahora, si quieres ser un buen programador aprende a manejar
bién las cadenas(strings). Estas también son muy
importantes para entregar los resultados matemáticos en
forma más legible para el típico usuario.
Hagamos un programa que dado un texto en "minúsculas"
nos lo entregue en "MAYUSCULAS".
Antes que nada diremos que el código de la letra
"A" en la hp48 es el número 65 y el de la letra "a" es el
97. Entonces, sabiendo que el texto dado está en
minúsculas, lo que tenemos que hacer es restarle al
código de cada letra del texto la cantidad (97-65=32) y
volverla a transformar en caracter otra
vez.
El código que yo escribí para esto fué
:
(Atención. La persona que
escriba un programa que yo le pida, como los ejercicios, y lo
haga con menos código que yo, o más rápido,
pondré su nombre en este manual)
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM 32 –
CHR Z SWAP REPL NEXT >>
Nunca pensé que sería tan fácil, en
serio. Este código transforma un texto que está en
minúsculas a MAYUSCULAS. Si se analiza el código,
la duración de la ejecución depende de la cantidad
de caracteres que tiene el texto, ya que el programa cambia cada
caracter por su mayuscula.
Bien, ahora, vamos a ir por partes arreglando el
código. Primero que nada, este programa sirve solo para
cadenas que no contengan espacios, o sea solo para palabras, ya
que el caracter espacio lo transforma también.
Eso yo lo arreglaría así :
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP
IF 32 != THEN 32 – END CHR Z SWAP REPL NEXT >>
Recuerda que el signo != representa en este manual a
DIFERENTE
o sea lo contrario del signo ==.
¿Puedes hacer el programa con el signo == ???
Demasiado fácil, una ofensa ???
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP
IF 32 == THEN CHR Z SWAP REPL NEXT END 32 –
>>
Sigamos perfeccionando el código. Pero primero hagamos
un programa que transforme un texto de MAYUSCULAS a
minúsculas :
No podría ser más fácil….
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP
IF 32 != THEN 32 + END CHR Z SWAP REPL NEXT >>
o también :
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP
IF 32 == THEN CHR Z SWAP REPL NEXT END 32 +
>>
Bueno, pero sigamos webeando un ratito. Ahora quiero que hagas
un programa que transforme todas las letras de un texto a
Mayúsculas, o Sea lo mismo que lo anterior, pero que las
letras MAYUSCULAS se mantengan así.
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP
IF 96 > THEN 32 – END CHR Z SWAP REPL NEXT >>
Y lo contrario seria :
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM DUP DUP
97 < SWAP 33 > IF AND THEN 32 + END CHR Z SWAP REPL NEXT
>>
No sé, pero quizá el último código
se pueda optimizar un poquito. Traten ustedes ;-)))
Ahora, a lo que queríamos llegar, un programa que
cambíe todas las letras de mayúscula a
minúscula o de minúscula a mayúscula
según sea el caso de que la letra sea minúscula o
mayúscula y que no modifique los espacios.
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM -> A
<< CASE 'A==32' THEN CHR Z SWAP REPL END
'A>97' THEN 32 – CHR Z SWAP REPL END
32 + CHR Z SWAP REPL END >> >>
Ya estamos listos.
Ahora, si el texto tubiera otros caracteres raros aparte de
las letras y los espacios, los cuales no quisieramos modificar
:
<< DUP 1 OVER SIZE FOR Z DUP Z DUP SUB NUM -> A
<< CASE 'A==32' THEN CHR Z SWAP REPL END
'A>97 AND A<123' THEN 32 – CHR Z SWAP REPL END
'A>64 AND A<91 THEN 32 + CHR Z SWAP REPL END
END >> >>
Recuerden que no todos los códigos los pruebo,
así que si alguno tiene falla lo arreglas y/o me
avisas.
Dejemos tranquilas un rato a las cadenas.
Alguien se acuerda del programa ESTRIANGULADOR ?
Aquí esta la version 2 que resuelve también las
simetrales :
@******************************************************************@
@——————- Programa ESTRIANGULADOR 2
——————–@
@———————— by xj35u5x
——————————@
@******************************************************************@
@ Módulo : HERON
@ Código :
<< -> A B C << A B C + + 2 / -> S
'(S*(S-A)*(S-B)*(S-C))^0.5' >> >>
@ Módulo : ARO
@ Código :
<< -> A B C << A 2 ^ B 2 ^ C 2 ^ -> a b c
<< a b c + < b a c + <
c a b + < OR IF OR THEN "ACUTANGULO" MSGBOX ELSE a b c +
==
b c a + == c a b + == OR IF OR THEN "RECTANGULO" MSGBOX
ELSE
a b c + > c a b + > b a c + > OR IF OR THEN
"OBTUSANGULO"
MSGBOX END END END >> >> >>
@ Módulo : ANGULOS
@ Código :
<< DEG
-> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C * * / ACOS A
2 ->LIST
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS B 2 ->LIST
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS C 2 ->LIST
>> >>
@ Módulo : ALTURAS
@ Código :
<< -> A B C << A B C HERON -> AREA <<
AREA 2 * A / A 2 ->LIST
AREA 2 * B / B 2 ->LIST
AREA 2 * C / C 2 ->LIST
>> >> >>
@ Módulo : TRANSVERSAL
@ Código :
<< -> A B C << A 2 / B 2 / C 2 /
B 2 ^ C 2 ^ + A 2 ^ – 2 B C * * / ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS
-> a b c ALFA BETA GAMMA <<
C 2 ^ a 2 ^ + C a * 2 * BETA COS * – 0.5 ^ A 2 ->LIST
A 2 ^ b 2 ^ + A b * 2 * GAMMA COS * – 0.5 ^ B 2 ->LIST
B 2 ^ c 2 ^ + B c * 2 * ALFA COS * – 0.5 ^ C 2 ->LIST
>> >> >>
@ Módulo : BISECTRIZ
@ Código :
<< DEG -> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C
* * / ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS
-> alfa beta gamma <<
C beta SEN * 180 beta – alfa 2 / – SEN / A 2 ->LIST
A gamma SEN * 180 gamma – beta 2 / – SEN / B 2 ->LIST
B alfa SEN * 180 alfa – gamma 2 / – SEN / C 2 ->LIST
>> >> >>
@Módulo : SIMETRAL
@Código :
<< DEG -> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C
* * / ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS
-> X Y Z
<< IF 'Z<Y' THEN Z TAN
ELSE Y TAN END
A * 2 / "s" A + ->TAG
IF 'Y<X' THEN Y TAN
ELSE X TAN END
B * 2 / "s" B + ->TAG
IF 'Y<X' THEN Y TAN
ELSE X TAN END
C * 2 / "s" C + ->TAG >> >> >>
@******************************************************************@
@ Programado por Sebastian Rivas milun[arroba]starmedia.com
@
@ Concepcion-Chile año 2000 copyleft .(v+s+j). @
@******************************************************************@
La optimización de este código era transformar
el código :
<< -> A B C << B 2 ^ C 2 ^ + A 2 ^ – 2 B C * *
/ ACOS
A 2 ^ C 2 ^ + B 2 ^ – 2 A C * * / ACOS
A 2 ^ B 2 ^ + C 2 ^ – 2 A B * * / ACOS >>
En un módulo aparte, ya que se repetía en varios
de los otros módulos. De este modo se ahorra espacio.
5. "Cadenas avanzadas, la encripción"
Yo siempre he encontrado la raja la palabra encripción.
Me gusta como suena, como a misterio, como a un
jeroglífico. Y justo eso es lo que se trata de hacer en la
encripción, esconder un texto de manera conveniente.
Un ejemplo muy muy muy básico de encripción
sería por ejemplo a cada letra de un texto sumarle tanto
para que cada letra cambié y sea ilegible. Digo que
sería un ejemplo muy básico por que no sería
nada de dificil desencriptar ese texto. La gracia de la
encripción es que el texto encriptado sea muy dificil de
desencriptar, y ojalá imposible(esto es imposible), de
manera que solo bajo determinadas condiciones se pueda recuperar
el texto encriptado. Ya sea mediante una clave o algo
así.
Me voy por un tiempo.
Son las 3:02 de la mañana. Estoy bajando el
último disco de therion. El DEGGIAL. Oye, un consejo….si
te gusta la música anda a
www.napster.com o www.imesh.com pura música
gratis…….
<< 1 OVER SIZE FOR R DUP R DUP SUB NUM 15 + CHR R SWAP
REPL NEXT >>
Ahí está nuestro primer encriptador.
Se debe tener en cuenta que la hp cuenta con 255 caracteres
ascii y que no
hay que preocuparse por que en alguna de las sumas de
encripción se supere esta cifra, ya que la hp lo arregla
por nosotros igual que los ángulos(450º=90º), o
sea que el caracter 257 es el 2.
Ahora, como sería el "crackeador" de nuestro ejemplo de
encripción ??
Si no se te ocurre….mmmmmmmm……bueno, no importa.
<< 1 OVER SIZE FOR R DUP R DUP SUB NUM 15 – CHR R SWAP
REPL NEXT >>
Hay que preocuparse eso sí por el signo – ya que para
este ejemplo no hay problema, puesto que es el crack del
anterior, pero si este fuera un encriptador, hay que cuidarse del
– por que todos los caracteres negativos la hp los toma como el
caracter 0. Con esto quiero decir que en todo proceso de
encripcion que se desarrolle en la hp48 se deve tener en cuenta
que el cambio de
caracter siempre debe ser por otro cuyo código sea MAYOR
que el primero.
Veamos otro ejemplo un poquitin más complejo :
<< 1 OVER SIZE FOR R DUP R DUP SUB NUM 1 + CHR R SWAP
REPL
DUP R 1 + DUP SUB NUM 2 + CHR R 1 + SWAP REPL 2 STEP
>>
Este ya sería un poco más complicadito, aunque
muy básico aún. Pero al menos ya costaría un
poco darse cuenta del algoritmo de
encripción.
También se podría combinar este programa con uno
que de vuelta entera la cadena.
<< 1 OVER SIZE START DUP HEAD + TAIL NEXT
1 OVER SIZE FOR R DUP R DUP SUB NUM 1 + CHR R SWAP REPL
DUP R 1 + DUP SUB NUM 2 + CHR R 1 + SWAP REPL 2 STEP
>>
Lo que está con negrita es lo que da vuelta la cadena.
Luego se aplica un encriptador y el resultado es un poco
más rebuscado.
Tengan en cuenta que la gracia del manual es que ustedes vayan
creando cosas al mismo tiempo que yo les voy enseñando
ideas.
Bueno, pero hagamosle una pruebita al encriptadorrrr :
Si ingreso el texto "temuco es una bella ciudad"
lo que obtengo es : " "
Lo primero que se me viene a la mente si estamos hablando de
ocultar el texto original, es que la segunda cadena tiene el
mismo SIZE que la primera, así que esto se debe solucionar
de forma inteligente. A ver….no podemos ponerle a cada texto
que encriptemos unos caracteres de más siempre iguales, ya
que el posible "desencriptador"
se daría cuenta de que todos los textos encriptados
siempre comienzan con la misma cosa o terminan con la misma cosa.
Lo que se me ocurre es que se le sumen caracteres al texto de
acuerdo al texto, o sea que se varíe segun el texto el
número de caracteres a añadir. Es una buena
idea.
A todas las personas que lean este manual, les pido una
cooperacion. La verdad de las cosas es que yo hago este manual
para ayudar a la gente que tenga ganas de aprender a programar su
hp48, pero para mi es imposible saber si este esta siendo leyendo
por alguien, así pues, pido una facil cooperación,
lo único que quiero es que si tu estas leyendo esto, me
envies un e-mail
Eso es lo único, porfa, para saber si alguien necesita
que siga escribiendo el manual. Y para que no piensen que este es
el final del manual aquí les dejo algo importante para mi.
El código de la pelotita que salta por toda la
pantalla…..
usando pview :
<< << { XJ3 } PURGE (0.5,0.5) XJ3 STO ERASE
(0,0) PIXON
{ #0h #0h } PVIEW (0,0) Q2 >> Q1 STO
<< DUP C->R -> Y A B << Y PIXOFF
IF 'A>6' THEN { XJ3 } (1,0) STO- END
IF 'B>3' THEN { XJ3 } (0,1) STO- END
IF 'A<-5.5' THEN { XJ3 } (1,0) STO+ END
IF 'B<-3' THEN { XJ3 } (0,1) STO+ END
Y XJ3 + PIXON { #0h #0h } KEY
IF 0 == THEN PVIEW Y XJ3 + Q2
ELSE { XJ3 PPAR Q1 Q2 } PURGE "by xj35u5x" MSGBOX
CLEAR END >> >> Q2 STO Q2 >>
usando animate :
<< GROB 1 1 10 WQ STO
GROB 1 1 00 WQ2 STO
<< { KK2 } RCL BYTES IF B767h == THEN
{ XJ32 PPAR KK1 KK2 WQ WQ2 } PURGE (0.5,0.5) XJ32 STO
ERASE PICT RCL (0,0)
WQ GOR { 1 { #0h #0h } 0 1 } ANIMATE (0,0) KK2 >>
KK1 STO ELSE VARS PURGE END
<<
DUP C->R -> T A B << SWAP T WQ2 REPL
IF 'A>5.8' THEN { XJ32 } (1,0) STO- END
IF 'B>2.5' THEN { XJ32 } (0,1) STO- END
IF 'A<-5.7' THEN { XJ32 } (1,0) STO+ END
IF 'B<-2.8' THEN { XJ32 } (0,1) STO+ END
T XJ32 + WQ GOR SWAP KEY
IF 0 == THEN ANIMATE T XJ32 + KK2
ELSE { PPAR XJ32 KK1 KK2 WQ WQ2 } PURGE CLEAR
"by xj35u5x" MSGBOX END >> >> KK2 STO
KK1 >>
Es evidente que el programa corre mucho más
rápido con PVIEW pero se debe tener en cuenta la ventaja
que con ANIMATE se puede cambiar el tonto punto por una figura
predefinida por nosotros. Si se quiere hacer correr el ejemplo
tengase en cuenta no modificarlo 😉
Saludos a la facultad de ingenieria de la universidad de
concepcion, plaga de ignorantes cuicos que no conocen las
potencialidades de su calculadora……
;->>>>>>> (a quien le caiga).
Trabajo enviado y realizado por:
Sebastian Rivas
Universidad de Concepcion-Chile
 Página anterior | Volver al principio del trabajo | Página siguiente  |